package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade PESSOA
 * @author Gerado pelo Telescope
 */
public class EntPessoa extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.PESSOA";
    public final static String TABLE_NAME = "PESSOA";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntPessoa() {
        super();
        initialize();
    }
    
    public EntPessoa(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Nome da pessoa"); 
        aNome.setRequired(true);
        aNome.setSize(32);
        oNome = new DomUpper();
        aSobrenome = new DomUpper(this,"SOBRENOME", "Sobrenome da pessoa"); 
        aSobrenome.setRequired(true);
        aSobrenome.setSize(32);
        oSobrenome = new DomUpper();
        aCodigo = new DomUpper(this,"CODIGO", "Código da pessoa"); 
        aCodigo.setRequired(true);
        aCodigo.setSize(32);
        oCodigo = new DomUpper();
        aEMail = new DomEMail(this,"E_MAIL", "Email da pessoa"); 
        aEMail.setSize(50);
        oEMail = new DomEMail();
        aUsuarioAssociadoId = new DomId(this,"USUARIO_ASSOCIADO_ID", "Usuário associado"); 
        oUsuarioAssociadoId = new DomId();
        aCodigoNumerico = new DomInteger(this,"CODIGO_NUMERICO", "Código numérico da pessoa"); 
        oCodigoNumerico = new DomInteger();
        aAtivo = new DomFlag(this,"ATIVO", "Ativo (pessoa ok)"); 
        aAtivo.setRequired(true);
        aAtivo.setDefaultValue("S");
        oAtivo = new DomFlag();
        aNomeApresentacao = new DomUpper(this,"NOME_APRESENTACAO", "Nome completo da pessoa"); 
        aNomeApresentacao.setRequired(true);
        aNomeApresentacao.setSize(128);
        oNomeApresentacao = new DomUpper();
        aTipoPessoaId = new DomId(this,"TIPO_PESSOA_ID", "Tipo da pessoa"); 
        aTipoPessoaId.setRequired(true);
        oTipoPessoaId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Nome da pessoa
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Sobrenome da pessoa
    private DomUpper aSobrenome;
    private DomUpper oSobrenome;
    
    // Código da pessoa
    private DomUpper aCodigo;
    private DomUpper oCodigo;
    
    // Email da pessoa
    private DomEMail aEMail;
    private DomEMail oEMail;
    
    // Usuário associado
    private DomId aUsuarioAssociadoId;
    private DomId oUsuarioAssociadoId;
    
    // Código numérico da pessoa
    private DomInteger aCodigoNumerico;
    private DomInteger oCodigoNumerico;
    
    // Ativo (pessoa ok)
    private DomFlag aAtivo;
    private DomFlag oAtivo;
    
    // Nome completo da pessoa
    private DomUpper aNomeApresentacao;
    private DomUpper oNomeApresentacao;
    
    // Tipo da pessoa
    private DomId aTipoPessoaId;
    private DomId oTipoPessoaId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntPessoa id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntPessoa nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SOBRENOME">
    
    public EntPessoa sobrenome(String value) {
        setSobrenome(value);
        return this;
    }
    
    public void setSobrenome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifySobrenome();
        } else {
            aSobrenome.setValue(value.getValue());
            if (aSobrenome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSobrenome(String value) {
        if (value == null) {
            nullifySobrenome();
        } else {
            aSobrenome.setValue(value);
            if (aSobrenome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSobrenome(Object value) {
        aSobrenome.setValue(value);
        if (aSobrenome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySobrenome() {
        if (!aSobrenome.isNull()) {
            aSobrenome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getSobrenome() {
        return aSobrenome;
    }
    
    public DomUpper oldSobrenome() {
        return oSobrenome;
    }
    
    public String valueOfSobrenome() {
        return aSobrenome.getValue();
    }
    
    public boolean isSobrenomeModified() {
        return aSobrenome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CODIGO">
    
    public EntPessoa codigo(String value) {
        setCodigo(value);
        return this;
    }
    
    public void setCodigo(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value.getValue());
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(String value) {
        if (value == null) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value);
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(Object value) {
        aCodigo.setValue(value);
        if (aCodigo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCodigo() {
        if (!aCodigo.isNull()) {
            aCodigo.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getCodigo() {
        return aCodigo;
    }
    
    public DomUpper oldCodigo() {
        return oCodigo;
    }
    
    public String valueOfCodigo() {
        return aCodigo.getValue();
    }
    
    public boolean isCodigoModified() {
        return aCodigo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo E_MAIL">
    
    public EntPessoa eMail(String value) {
        setEMail(value);
        return this;
    }
    
    public void setEMail(DomEMail value) {
        if (value == null || value.isNull()) {
            nullifyEMail();
        } else {
            aEMail.setValue(value.getValue());
            if (aEMail.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEMail(String value) {
        if (value == null) {
            nullifyEMail();
        } else {
            aEMail.setValue(value);
            if (aEMail.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEMail(Object value) {
        aEMail.setValue(value);
        if (aEMail.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyEMail() {
        if (!aEMail.isNull()) {
            aEMail.setNull(true);
            setModified(true);
        }
    }
    
    public DomEMail getEMail() {
        return aEMail;
    }
    
    public DomEMail oldEMail() {
        return oEMail;
    }
    
    public String valueOfEMail() {
        return aEMail.getValue();
    }
    
    public boolean isEMailModified() {
        return aEMail.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo USUARIO_ASSOCIADO_ID">
    
    public EntPessoa usuarioAssociadoId(Long value) {
        setUsuarioAssociadoId(value);
        return this;
    }
    
    public void setUsuarioAssociadoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyUsuarioAssociadoId();
        } else {
            aUsuarioAssociadoId.setValue(value.getValue());
            if (aUsuarioAssociadoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUsuarioAssociadoId(String value) {
        if (value == null) {
            nullifyUsuarioAssociadoId();
        } else {
            aUsuarioAssociadoId.setValue(value);
            if (aUsuarioAssociadoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUsuarioAssociadoId(Long value) {
        aUsuarioAssociadoId.setValue(value);
        if (aUsuarioAssociadoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setUsuarioAssociadoId(Object value) {
        aUsuarioAssociadoId.setValue(value);
        if (aUsuarioAssociadoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUsuarioAssociadoId() {
        if (!aUsuarioAssociadoId.isNull()) {
            aUsuarioAssociadoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getUsuarioAssociadoId() {
        return aUsuarioAssociadoId;
    }
    
    public DomId oldUsuarioAssociadoId() {
        return oUsuarioAssociadoId;
    }
    
    public Long valueOfUsuarioAssociadoId() {
        return aUsuarioAssociadoId.getValue();
    }
    
    public boolean isUsuarioAssociadoIdModified() {
        return aUsuarioAssociadoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CODIGO_NUMERICO">
    
    public EntPessoa codigoNumerico(Integer value) {
        setCodigoNumerico(value);
        return this;
    }
    
    public void setCodigoNumerico(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyCodigoNumerico();
        } else {
            aCodigoNumerico.setValue(value.getValue());
            if (aCodigoNumerico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigoNumerico(String value) {
        if (value == null) {
            nullifyCodigoNumerico();
        } else {
            aCodigoNumerico.setValue(value);
            if (aCodigoNumerico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigoNumerico(Integer value) {
        aCodigoNumerico.setValue(value);
        if (aCodigoNumerico.isModified()) {
            setModified(true);
        }
    }
    
    public void setCodigoNumerico(Object value) {
        aCodigoNumerico.setValue(value);
        if (aCodigoNumerico.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCodigoNumerico() {
        if (!aCodigoNumerico.isNull()) {
            aCodigoNumerico.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getCodigoNumerico() {
        return aCodigoNumerico;
    }
    
    public DomInteger oldCodigoNumerico() {
        return oCodigoNumerico;
    }
    
    public Integer valueOfCodigoNumerico() {
        return aCodigoNumerico.getValue();
    }
    
    public boolean isCodigoNumericoModified() {
        return aCodigoNumerico.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ATIVO">
    
    public EntPessoa ativo(String value) {
        setAtivo(value);
        return this;
    }
    
    public void setAtivo(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value.getValue());
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(String value) {
        if (value == null) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value);
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(Object value) {
        aAtivo.setValue(value);
        if (aAtivo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAtivo() {
        if (!aAtivo.isNull()) {
            aAtivo.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getAtivo() {
        return aAtivo;
    }
    
    public DomFlag oldAtivo() {
        return oAtivo;
    }
    
    public String valueOfAtivo() {
        return aAtivo.getValue();
    }
    
    public boolean isAtivoModified() {
        return aAtivo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME_APRESENTACAO">
    
    public EntPessoa nomeApresentacao(String value) {
        setNomeApresentacao(value);
        return this;
    }
    
    public void setNomeApresentacao(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNomeApresentacao();
        } else {
            aNomeApresentacao.setValue(value.getValue());
            if (aNomeApresentacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNomeApresentacao(String value) {
        if (value == null) {
            nullifyNomeApresentacao();
        } else {
            aNomeApresentacao.setValue(value);
            if (aNomeApresentacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNomeApresentacao(Object value) {
        aNomeApresentacao.setValue(value);
        if (aNomeApresentacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNomeApresentacao() {
        if (!aNomeApresentacao.isNull()) {
            aNomeApresentacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNomeApresentacao() {
        return aNomeApresentacao;
    }
    
    public DomUpper oldNomeApresentacao() {
        return oNomeApresentacao;
    }
    
    public String valueOfNomeApresentacao() {
        return aNomeApresentacao.getValue();
    }
    
    public boolean isNomeApresentacaoModified() {
        return aNomeApresentacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_PESSOA_ID">
    
    public EntPessoa tipoPessoaId(Long value) {
        setTipoPessoaId(value);
        return this;
    }
    
    public void setTipoPessoaId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyTipoPessoaId();
        } else {
            aTipoPessoaId.setValue(value.getValue());
            if (aTipoPessoaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoPessoaId(String value) {
        if (value == null) {
            nullifyTipoPessoaId();
        } else {
            aTipoPessoaId.setValue(value);
            if (aTipoPessoaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoPessoaId(Long value) {
        aTipoPessoaId.setValue(value);
        if (aTipoPessoaId.isModified()) {
            setModified(true);
        }
    }
    
    public void setTipoPessoaId(Object value) {
        aTipoPessoaId.setValue(value);
        if (aTipoPessoaId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoPessoaId() {
        if (!aTipoPessoaId.isNull()) {
            aTipoPessoaId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getTipoPessoaId() {
        return aTipoPessoaId;
    }
    
    public DomId oldTipoPessoaId() {
        return oTipoPessoaId;
    }
    
    public Long valueOfTipoPessoaId() {
        return aTipoPessoaId.getValue();
    }
    
    public boolean isTipoPessoaIdModified() {
        return aTipoPessoaId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_DESCONTINUACAO
        {
            EntPlanoExecucao external = new EntPlanoExecucao(ctx);
            external.findByResponsavelDescontinuacao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_DESCONTINUACAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_APROVACAO
        {
            EntPlanoExecucao external = new EntPlanoExecucao(ctx);
            external.findByResponsavelAprovacao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_APROVACAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_ELABORACAO
        {
            EntPlanoExecucao external = new EntPlanoExecucao(ctx);
            external.findByResponsavelElaboracao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_ELABORACAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.OPERADOR_INSTRUMENTO.FK_OPRINS_OPERADOR
        {
            EntOperadorInstrumento external = new EntOperadorInstrumento(ctx);
            external.findByOperadorInstrumento(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.OPERADOR_INSTRUMENTO.FK_OPRINS_OPERADOR.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Operadores dos instrumentos fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.ENSAIO_BANCADA.FK_ENBANC_OPERADOR_ENSAIO
        {
            EntEnsaioBancada external = new EntEnsaioBancada(ctx);
            external.findByOperadorEnsaio(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_OPERADOR_ENSAIO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_APROVADO_POR
        {
            EntInstrucaoTrabalho external = new EntInstrucaoTrabalho(ctx);
            external.findByAprovadoPor(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_APROVADO_POR.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_ELABORADO_POR
        {
            EntInstrucaoTrabalho external = new EntInstrucaoTrabalho(ctx);
            external.findByElaboradoPor(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_ELABORADO_POR.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_PLAEX_RESPONSAVEL_DESCONTINUACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_DESCONTINUACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro! (FK_PLAEX_RESPONSAVEL_DESCONTINUACAO)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_RESPONSAVEL_APROVACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_APROVACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro! (FK_PLAEX_RESPONSAVEL_APROVACAO)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_RESPONSAVEL_ELABORACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_ELABORACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Planos de ensaios fazendo referencia para este registro! (FK_PLAEX_RESPONSAVEL_ELABORACAO)");
                return e;
            } else if (msg.indexOf("FK_OPRINS_OPERADOR") >= 0) {
                e = new AdsException("ZTEST.OPERADOR_INSTRUMENTO.FK_OPRINS_OPERADOR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Operadores dos instrumentos fazendo referencia para este registro! (FK_OPRINS_OPERADOR)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_OPERADOR_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_OPERADOR_ENSAIO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro! (FK_ENBANC_OPERADOR_ENSAIO)");
                return e;
            } else if (msg.indexOf("FK_INSTRA_APROVADO_POR") >= 0) {
                e = new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_APROVADO_POR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro! (FK_INSTRA_APROVADO_POR)");
                return e;
            } else if (msg.indexOf("FK_INSTRA_ELABORADO_POR") >= 0) {
                e = new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_ELABORADO_POR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro! (FK_INSTRA_ELABORADO_POR)");
                return e;
            } else {
                e = new AdsException("ZTEST.PESSOA.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("FK_PESS_TIPO_PESSOA") >= 0) {
                e = new AdsException("ZTEST.PESSOA.FK_PESS_TIPO_PESSOA", 
                        Severity.ERROR,
                        "Registro não cadastrado para TIPO_PESSOA! (FK_PESS_TIPO_PESSOA)");
                return e;
            } else if (msg.indexOf("UK_PESS_USUARIO") >= 0) {
                e = new AdsException("ZTEST.PESSOA.UK_PESS_USUARIO", 
                        Severity.ERROR,
                        "Registro duplicado! Usuário associado deve ser único Usuário associado ${USUARIO_ASSOCIADO_ID} (UK_PESS_USUARIO)");
                return e;
            } else if (msg.indexOf("UK_PESS_CODIGO") >= 0) {
                e = new AdsException("ZTEST.PESSOA.UK_PESS_CODIGO", 
                        Severity.ERROR,
                        "Registro duplicado! Código da pessoa deve ser único! Código da pessoa ${CODIGO} (UK_PESS_CODIGO)");
                return e;
            } else if (msg.indexOf("UK_PESS_NOME_SOBRENOME") >= 0) {
                e = new AdsException("ZTEST.PESSOA.UK_PESS_NOME_SOBRENOME", 
                        Severity.ERROR,
                        "Registro duplicado! Nome e sobrenome (nome de apresentação) devem ser únicos Nome completo da pessoa ${NOME_APRESENTACAO} (UK_PESS_NOME_SOBRENOME)");
                return e;
            } else if (msg.indexOf("FK_PESS_USUARIO_ASSOCIADO") >= 0) {
                e = new AdsException("ZTEST.PESSOA.FK_PESS_USUARIO_ASSOCIADO", 
                        Severity.ERROR,
                        "Registro não cadastrado para USUARIO_ASSOCIADO! (FK_PESS_USUARIO_ASSOCIADO)");
                return e;
            } else if (msg.indexOf("PK_PESS") >= 0) {
                e = new AdsException("ZTEST.PESSOA.PK_PESS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PESS)");
                return e;
            } else {
                e = new AdsException("ZTEST.PESSOA.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aSobrenome);
            allAttributes.add(aCodigo);
            allAttributes.add(aEMail);
            allAttributes.add(aUsuarioAssociadoId);
            allAttributes.add(aCodigoNumerico);
            allAttributes.add(aAtivo);
            allAttributes.add(aNomeApresentacao);
            allAttributes.add(aTipoPessoaId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNomeApresentacao().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNomeApresentacao(String nomeApresentacao) throws AdsException {
        findBy(new String[] {"NOME_APRESENTACAO"},
                new Object[] {nomeApresentacao});
    }
    
    public void findByCodigo(String codigo) throws AdsException {
        findBy(new String[] {"CODIGO"},
                new Object[] {codigo});
    }
    
    public void findByUsuarioAssociadoId(long usuarioAssociadoId) throws AdsException {
        findBy(new String[] {"USUARIO_ASSOCIADO_ID"},
                new Object[] {usuarioAssociadoId});
    }
    
    private EntTipoPessoa eTipoPessoa;
    
    public EntTipoPessoa findTipoPessoa() throws AdsException {
        if (getTipoPessoaId().isNull()) {
            return null;
        }
        if (eTipoPessoa == null || !valueOfTipoPessoaId().equals(eTipoPessoa.valueOfId())) {
            eTipoPessoa = new EntTipoPessoa(ctx);
            eTipoPessoa.find(valueOfTipoPessoaId());
        }
        return eTipoPessoa;
    }
    
    /**
     * Ativa o join desta entidade com TIPO_PESSOA
     * através do atributo TIPO_PESSOA_ID
     */
    public EntTipoPessoa joinTipoPessoa() {
        return joinTipoPessoa(null);
    }
    public EntTipoPessoa joinTipoPessoa(String alias) {
        EntTipoPessoa entity = new EntTipoPessoa(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getTipoPessoaId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByTipoPessoa(long id, String sqlAppend) throws AdsException {
        find("select ID from PESSOA where TIPO_PESSOA_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByTipoPessoa(long id) throws AdsException {
        findByTipoPessoa(id,"");
    }
    
    public void findByTipoPessoa(Entity entidade) throws AdsException {
        findByTipoPessoa(entidade.valueOfId(),"");
    }
    
    public void findByTipoPessoa(Entity entidade, String sqlAppend) throws AdsException {
        findByTipoPessoa(entidade.valueOfId(),sqlAppend);
    }
    
    private EntUsuarios eUsuarioAssociado;
    
    public EntUsuarios findUsuarioAssociado() throws AdsException {
        if (getUsuarioAssociadoId().isNull()) {
            return null;
        }
        if (eUsuarioAssociado == null || !valueOfUsuarioAssociadoId().equals(eUsuarioAssociado.valueOfId())) {
            eUsuarioAssociado = new EntUsuarios(ctx);
            eUsuarioAssociado.find(valueOfUsuarioAssociadoId());
        }
        return eUsuarioAssociado;
    }
    
    /**
     * Ativa o join desta entidade com USUARIOS
     * através do atributo USUARIO_ASSOCIADO_ID
     */
    public EntUsuarios joinUsuarioAssociado() {
        return joinUsuarioAssociado(null);
    }
    public EntUsuarios joinUsuarioAssociado(String alias) {
        EntUsuarios entity = new EntUsuarios(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getUsuarioAssociadoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByUsuarioAssociado(long id, String sqlAppend) throws AdsException {
        find("select ID from PESSOA where USUARIO_ASSOCIADO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByUsuarioAssociado(long id) throws AdsException {
        findByUsuarioAssociado(id,"");
    }
    
    public void findByUsuarioAssociado(Entity entidade) throws AdsException {
        findByUsuarioAssociado(entidade.valueOfId(),"");
    }
    
    public void findByUsuarioAssociado(Entity entidade, String sqlAppend) throws AdsException {
        findByUsuarioAssociado(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eTipoPessoa = null;
        eUsuarioAssociado = null;
    }
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_DESCONTINUACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelDescontinuacao() throws AdsException {
        return findAllPlanoExecucaoResponsavelDescontinuacao("order by ID");
    }
    
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_DESCONTINUACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelDescontinuacao(String sqlAppend) throws AdsException {
        EntPlanoExecucao out = new EntPlanoExecucao(ctx);
        out.find("select ID from PLANO_EXECUCAO where RESPONSAVEL_DESCONTINUACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_APROVACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelAprovacao() throws AdsException {
        return findAllPlanoExecucaoResponsavelAprovacao("order by ID");
    }
    
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_APROVACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelAprovacao(String sqlAppend) throws AdsException {
        EntPlanoExecucao out = new EntPlanoExecucao(ctx);
        out.find("select ID from PLANO_EXECUCAO where RESPONSAVEL_APROVACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_ELABORACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelElaboracao() throws AdsException {
        return findAllPlanoExecucaoResponsavelElaboracao("order by ID");
    }
    
    /**
     * Retorna os registros de PLANO_EXECUCAO que referenciam este registro através do atributo RESPONSAVEL_ELABORACAO_ID
     */
    public EntPlanoExecucao findAllPlanoExecucaoResponsavelElaboracao(String sqlAppend) throws AdsException {
        EntPlanoExecucao out = new EntPlanoExecucao(ctx);
        out.find("select ID from PLANO_EXECUCAO where RESPONSAVEL_ELABORACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de OPERADOR_INSTRUMENTO que referenciam este registro através do atributo OPERADOR_INSTRUMENTO_ID
     */
    public EntOperadorInstrumento findAllOperadorInstrumentoOperadorInstrumento() throws AdsException {
        return findAllOperadorInstrumentoOperadorInstrumento("order by ID");
    }
    
    /**
     * Retorna os registros de OPERADOR_INSTRUMENTO que referenciam este registro através do atributo OPERADOR_INSTRUMENTO_ID
     */
    public EntOperadorInstrumento findAllOperadorInstrumentoOperadorInstrumento(String sqlAppend) throws AdsException {
        EntOperadorInstrumento out = new EntOperadorInstrumento(ctx);
        out.find("select ID from OPERADOR_INSTRUMENTO where OPERADOR_INSTRUMENTO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo OPERADOR_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaOperadorEnsaio() throws AdsException {
        return findAllEnsaioBancadaOperadorEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo OPERADOR_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaOperadorEnsaio(String sqlAppend) throws AdsException {
        EntEnsaioBancada out = new EntEnsaioBancada(ctx);
        out.find("select ID from ENSAIO_BANCADA where OPERADOR_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo APROVADO_POR_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoAprovadoPor() throws AdsException {
        return findAllInstrucaoTrabalhoAprovadoPor("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo APROVADO_POR_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoAprovadoPor(String sqlAppend) throws AdsException {
        EntInstrucaoTrabalho out = new EntInstrucaoTrabalho(ctx);
        out.find("select ID from INSTRUCAO_TRABALHO where APROVADO_POR_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo ELABORADO_POR_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoElaboradoPor() throws AdsException {
        return findAllInstrucaoTrabalhoElaboradoPor("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo ELABORADO_POR_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoElaboradoPor(String sqlAppend) throws AdsException {
        EntInstrucaoTrabalho out = new EntInstrucaoTrabalho(ctx);
        out.find("select ID from INSTRUCAO_TRABALHO where ELABORADO_POR_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oTipoPessoaId.setValue(aTipoPessoaId);
        oNomeApresentacao.setValue(aNomeApresentacao);
        oAtivo.setValue(aAtivo);
        oEMail.setValue(aEMail);
        oCodigoNumerico.setValue(aCodigoNumerico);
        oUsuarioAssociadoId.setValue(aUsuarioAssociadoId);
        oCodigo.setValue(aCodigo);
        oNome.setValue(aNome);
        oSobrenome.setValue(aSobrenome);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setName("PK_PESS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setAssociatedEntity(EntTipoPessoa.class);
            rule.setName("FK_PESS_TIPO_PESSOA");
            rule.addAttribute(new DomId("TIPO_PESSOA_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setAssociatedEntity(EntUsuarios.class);
            rule.setName("FK_PESS_USUARIO_ASSOCIADO");
            rule.addAttribute(new DomId("USUARIO_ASSOCIADO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setName("UK_PESS_NOME_SOBRENOME");
            rule.addAttribute(new DomUpper("NOME_APRESENTACAO",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setName("UK_PESS_CODIGO");
            rule.addAttribute(new DomUpper("CODIGO",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPessoa.class);
            rule.setName("UK_PESS_USUARIO");
            rule.addAttribute(new DomId("USUARIO_ASSOCIADO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        calcularNomeApresentacao(); //Calcular o nome de apresentação da pessoa
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        calcularNomeApresentacao(); //Calcular o nome de apresentação da pessoa
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getAtivo().isNull()) {
            setAtivo(getAtivo().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Calcular nome de apresentação da pessoa.
     */
    public void calcularNomeApresentacaoPessoa(String regraNomeApresentacao) throws AdsException {
        // <user-code id="20729552" parentId="20729501" hashcode="-544a9e90" length="352">
        if (regraNomeApresentacao.equals("V")) {
            setNomeApresentacao(valueOfNome() + ", " + valueOfSobrenome());
        } else if (regraNomeApresentacao.equals("S")) {
            setNomeApresentacao(valueOfSobrenome() + ", " + valueOfNome());
        } else { // if (regraNomeApresentacao.equals("N")) {
            setNomeApresentacao(valueOfNome() + " " + valueOfSobrenome());
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular o nome de apresentação da pessoa
     */
    private void calcularNomeApresentacao() throws AdsException {
        // <user-code id="20674969" parentId="20674929" hashcode="-64e22241" length="133">
        if (isNomeModified() || isSobrenomeModified()) {
            calcularNomeApresentacaoPessoa(findTipoPessoa().valueOfRegraNomePessoa());
        }
        
        // </user-code>
    }
}
